Micron Document
`:top
`!Java bytecode`! is the instruction set of the `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f (JVM), the language to which `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_(programming_language)]`_`f and other JVM-compatible `F33f`_`[source code`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Source_code]`_`f is `F33f`_`[compiled`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Compiler]`_`f.`:cite-ref-oracle-jvm-spec-1-0[`F5bf`_`[1`#cite-note-oracle-jvm-spec-1]`_`f] Each instruction is represented by a single `F33f`_`[byte`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Byte]`_`f, hence the name `F33f`_`[bytecode`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Bytecode]`_`f, making it a compact form of `F33f`_`[data`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Data]`_`f.`:cite-ref-jvm-book-2-0[`F5bf`_`[2`#cite-note-jvm-book-2]`_`f]

Due to the nature of bytecode, a Java bytecode `F33f`_`[program`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Computer_program]`_`f is runnable on any machine with a compatible JVM, without the lengthy process of compiling from source code.

Java bytecode is used at `F33f`_`[runtime`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Runtime_(program_lifecycle_phase)]`_`f either `F33f`_`[interpreted`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Interpreter_(computing)]`_`f by a JVM or compiled to machine code via `F33f`_`[just-in-time`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Just-in-time_compilation]`_`f (JIT) compilation and run as a native application.

As Java bytecode is designed for a cross-platform compatibility and security, a Java bytecode application tends to run consistently across various `F33f`_`[hardware`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Computer_hardware]`_`f and `F33f`_`[software`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Software]`_`f configurations.`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]

>>Contents

• `F0af`_`[Relation to Java`#relation-to-java]`_`f
• `F0af`_`[Instruction set architecture`#instruction-set-architecture]`_`f
• `F0af`_`[Instruction set`#instruction-set]`_`f
• `F0af`_`[Example`#example]`_`f
• `F0af`_`[Generation`#generation]`_`f
• `F0af`_`[Execution`#execution]`_`f
• `F0af`_`[Support for dynamic languages`#support-for-dynamic-languages]`_`f
• `F0af`_`[See also`#see-also]`_`f
• `F0af`_`[References`#references]`_`f
• `F0af`_`[External links`#external-links]`_`f

-─

>>Relation to Java

In general, a Java `F33f`_`[programmer`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Programmer]`_`f does not need to understand Java bytecode or even be aware of it. However, as suggested in the `F33f`_`[IBM`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=IBM]`_`f developerWorks journal, "Understanding bytecode and what bytecode is likely to be generated by a `F33f`_`[Java compiler`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_compiler]`_`f helps the Java programmer in the same way that knowledge of `F33f`_`[assembly`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Assembly_language]`_`f helps the `F33f`_`[C`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C_(programming_language)]`_`f or `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C++]`_`f programmer."`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]

>>Instruction set architecture

The bytecode comprises various instruction types, including data manipulation, control transfer, object creation and manipulation, and method invocation, all integral to Java's object-oriented programming model.`:cite-ref-oracle-jvm-spec-1-1[`F5bf`_`[1`#cite-note-oracle-jvm-spec-1]`_`f]

The JVM is both a `F33f`_`[stack machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Stack_machine]`_`f and a `F33f`_`[register machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Register_machine]`_`f. Each `F33f`_`[frame`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Call_stack]`_`f for a method call has an "operand stack" and an array of "local variables".`:cite-ref-jvm-5-0[`F5bf`_`[5`#cite-note-jvm-5]`_`f] `:cite-ref-jvm-book-2-1[`F5bf`_`[2`#cite-note-jvm-book-2]`_`f] The operand stack is used for passing operands to computations and for receiving the return value of a called method, while local variables serve the same purpose as `F33f`_`[registers`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Processor_register]`_`f and are also used to pass method arguments. The maximum size of the operand stack and local variable array, computed by the compiler, is part of the attributes of each method.`:cite-ref-jvm-5-1[`F5bf`_`[5`#cite-note-jvm-5]`_`f] Each can be independently sized from 0 to 65535 values, where each value is 32 bits. `B100`F9d9long`f`b and `B100`F9d9double`f`b types, which are 64 bits, take up two consecutive local variables`:cite-ref-jvm-5-2[`F5bf`_`[5`#cite-note-jvm-5]`_`f] (which need not be 64-bit aligned in the local variables array) or one value in the operand stack (but are counted as two units in the depth of the stack).`:cite-ref-jvm-5-3[`F5bf`_`[5`#cite-note-jvm-5]`_`f]

>>>Instruction set

Each `F33f`_`[bytecode`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Bytecode]`_`f is composed of one byte that represents the `F33f`_`[opcode`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Opcode]`_`f, along with zero or more bytes for operands.`:cite-ref-jvm-5-4[`F5bf`_`[5`#cite-note-jvm-5]`_`f]

Of the 256 possible byte-long `F33f`_`[opcodes`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Opcode]`_`f, as of 2015, 202 are in use (~79%), 51 are reserved for future use (~20%), and 3 instructions (~1%) are permanently reserved for JVM implementations to use.`:cite-ref-jvm-5-5[`F5bf`_`[5`#cite-note-jvm-5]`_`f] Two of these (`B100`F9d9impdep1`f`b and `B100`F9d9impdep2`f`b) are to provide traps for implementation-specific software and hardware, respectively. The third is used for debuggers to implement breakpoints.

Instructions fall into a number of broad groups:

• Load and store (e.g. `B100`F9d9aload_0`f`b, `B100`F9d9istore`f`b)
• Arithmetic and logic (e.g. `B100`F9d9ladd`f`b, `B100`F9d9fcmpl`f`b)
• Type conversion (e.g. `B100`F9d9i2b`f`b, `B100`F9d9d2i`f`b)
• Object creation and manipulation (`B100`F9d9new`f`b, `B100`F9d9putfield`f`b)
• Operand stack management (e.g. `B100`F9d9swap`f`b, `B100`F9d9dup2`f`b)
• Control transfer (e.g. `B100`F9d9ifeq`f`b, `B100`F9d9goto`f`b)
• Method invocation and return (e.g. `B100`F9d9invokespecial`f`b, `B100`F9d9areturn`f`b)

There are also a few instructions for a number of more specialized tasks such as exception throwing, synchronization, etc.

Many instructions have prefixes and/or suffixes referring to the types of operands they operate on.`:cite-ref-jvm-5-6[`F5bf`_`[5`#cite-note-jvm-5]`_`f] These are as follows:

`t
| Prefix/suffix | Operand type |
|---|---|
| i | integer |
| l | long |
| s | short |
| b | byte |
| c | character |
| f | float |
| d | double |
| a | reference |
`t

For example, `B100`F9d9iadd`f`b will add two integers, while `B100`F9d9dadd`f`b will add two doubles. The `B100`F9d9const`f`b, `B100`F9d9load`f`b, and `B100`F9d9store`f`b instructions may also take a suffix of the form `B100`F9d9_`*n`*`f`b, where `*n`* is a number from 0–3 for `B100`F9d9load`f`b and `B100`F9d9store`f`b. The maximum `*n`* for `B100`F9d9const`f`b differs by type.

The `B100`F9d9const`f`b instructions push a value of the specified type onto the stack. For example, `B100`F9d9iconst_5`f`b will push an integer (32 bit value) with the value 5 onto the stack, while `B100`F9d9dconst_1`f`b will push a double (64 bit floating point value) with the value 1 onto the stack. There is also an `B100`F9d9aconst_null`f`b, which pushes a `B100`F9d9null`f`b reference. The `*n`* for the `B100`F9d9load`f`b and `B100`F9d9store`f`b instructions specifies the index in the local variable array to load from or store to. The `B100`F9d9aload_0`f`b instruction pushes the object in local variable 0 onto the stack (this is usually the `B100`F9d9`F33f`_`[this`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=This_(computer_programming)]`_`f`f`b object). `B100`F9d9istore_1`f`b stores the integer on the top of the stack into local variable 1. For local variables beyond 3 the suffix is dropped and operands must be used.

>>Example

Consider the following Java code:

`B100`F9d9outer:`f`b
`B100`F9d9for (int i = 2; i < 1000; i++) {`f`b
`B100`F9d9 for (int j = 2; j < i; j++) {`f`b
`B100`F9d9 if (i % j == 0)`f`b
`B100`F9d9 continue outer;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 System.out.println(i);`f`b
`B100`F9d9}`f`b

A Java compiler might translate the Java code above into bytecode as follows, assuming the above was put in a method:

`B100`F9d90: iconst_2`f`b
`B100`F9d91: istore_1`f`b
`B100`F9d92: iload_1`f`b
`B100`F9d93: sipush 1000`f`b
`B100`F9d96: if_icmpge 44`f`b
`B100`F9d99: iconst_2`f`b
`B100`F9d910: istore_2`f`b
`B100`F9d911: iload_2`f`b
`B100`F9d912: iload_1`f`b
`B100`F9d913: if_icmpge 31`f`b
`B100`F9d916: iload_1`f`b
`B100`F9d917: iload_2`f`b
`B100`F9d918: irem`f`b
`B100`F9d919: ifne 25`f`b
`B100`F9d922: goto 38`f`b
`B100`F9d925: iinc 2, 1`f`b
`B100`F9d928: goto 11`f`b
`B100`F9d931: getstatic #84; // Field java/lang/System.out:Ljava/io/PrintStream;`f`b
`B100`F9d934: iload_1`f`b
`B100`F9d935: invokevirtual #85; // Method java/io/PrintStream.println:(I)V`f`b
`B100`F9d938: iinc 1, 1`f`b
`B100`F9d941: goto 2`f`b
`B100`F9d944: return`f`b

>>Generation

The most common language targeting `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f by producing Java bytecode is Java. Originally only one compiler existed, the `F33f`_`[javac`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Javac]`_`f compiler from `F33f`_`[Sun Microsystems`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Sun_Microsystems]`_`f, which compiles `F33f`_`[Java source code`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_source_code]`_`f to Java bytecode; but because all the specifications for Java bytecode are now available, other parties have supplied compilers that produce Java bytecode. Examples of other compilers include:

• Eclipse compiler for Java (ECJ)
• `F33f`_`[Jikes`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Jikes]`_`f, compiles from Java to Java bytecode (developed by `F33f`_`[IBM`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=IBM]`_`f, implemented in `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C++]`_`f)
• Espresso, compiles from Java to Java bytecode (Java 1.0 only)
• `F33f`_`[GNU Compiler for Java`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=GNU_Compiler_for_Java]`_`f (GCJ), compiles from Java to Java bytecode; it can also compile to native `F33f`_`[machine code`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Machine_code]`_`f and was part of the `F33f`_`[GNU Compiler Collection`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=GNU_Compiler_Collection]`_`f (GCC) up until version 6.

Some projects provide Java assemblers to enable writing Java bytecode by hand. Assembly code may be also generated by machine, for example by a compiler targeting a `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f. Notable Java assemblers include:

• Jasmin, takes text descriptions for Java classes, written in a simple assembly-like syntax using Java virtual machine instruction set and generates a Java class file`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]
• Jamaica, a `F33f`_`[macro`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Macro_(computer_science)]`_`f `F33f`_`[assembly language`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Assembly_language]`_`f for the `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f. Java syntax is used for class or interface definition. Method bodies are specified using bytecode instructions.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]
• Krakatau Bytecode Tools, currently contains three tools: a decompiler and disassembler for Java classfiles and an assembler to create classfiles.`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f]
• Lilac, an assembler and disassembler for the `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f.`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f]

Others have developed compilers, for different programming languages, to target the Java virtual machine, such as:

• `F33f`_`[ColdFusion`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ColdFusion]`_`f
• `F33f`_`[JRuby`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=JRuby]`_`f and `F33f`_`[Jython`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Jython]`_`f, two `F33f`_`[scripting languages`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Scripting_language]`_`f based on `F33f`_`[Ruby`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Ruby_(programming_language)]`_`f and `F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Python_(programming_language)]`_`f
• `F33f`_`[Apache Groovy`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Groovy_(programming_language)]`_`f, optionally typed and dynamic general-purpose language, with static-typing and static compilation capabilities
• `F33f`_`[Scala`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Scala_(programming_language)]`_`f, a type-safe general-purpose programming language supporting object-oriented and functional programming
• `F33f`_`[JGNAT`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=JGNAT]`_`f and AppletMagic, compile from the language `F33f`_`[Ada`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Ada_(programming_language)]`_`f to Java bytecode
• `F33f`_`[C to Java byte-code compilers`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f
• `F33f`_`[Clojure`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Clojure]`_`f, a functional, immutable, general-purpose programming language in the `F33f`_`[Lisp`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Lisp_(programming_language)]`_`f family with a strong emphasis on concurrency
• `F33f`_`[Kawa`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Kawa_(Scheme_implementation)]`_`f, an implementation of the `F33f`_`[Scheme`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Scheme_(programming_language)]`_`f programming language, also a dialect of `F33f`_`[Lisp`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Lisp_(programming_language)]`_`f.
• MIDletPascal
• `F33f`_`[JavaFX Script`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=JavaFX_Script]`_`f code is compiled to Java bytecode
• `F33f`_`[Kotlin`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Kotlin_(programming_language)]`_`f, a statically-typed general-purpose programming language with type inference
• `F33f`_`[Object Pascal`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object_Pascal]`_`f source code is compiled to Java bytecode using the `F33f`_`[Free Pascal`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Free_Pascal]`_`f 3.0+ compiler.`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f]`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f]

>>Execution

There are several Java virtual machines available today to execute Java bytecode, both free and commercial products. If executing bytecode in a virtual machine is undesirable, a developer can also compile Java source code or bytecode directly to native machine code with tools such as the `F33f`_`[GNU Compiler for Java`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=GNU_Compiler_for_Java]`_`f (GCJ). Some processors can execute Java bytecode natively. Such processors are termed `*`F33f`_`[Java processors`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_processor]`_`f`*.

>>Support for dynamic languages

The `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f provides some support for `F33f`_`[dynamically typed languages`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Type_system]`_`f. Most of the extant JVM instruction set is `F33f`_`[statically typed`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Type_system]`_`f - in the sense that method calls have their signatures type-checked at `F33f`_`[compile time`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Compile_time]`_`f, without a mechanism to defer this decision to `F33f`_`[run time`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Run_time_(program_lifecycle_phase)]`_`f, or to choose the method dispatch by an alternative approach.`:cite-ref-12[`F5bf`_`[12`#cite-note-12]`_`f]

`F33f`_`[JSR`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_Community_Process]`_`f 292 (`*Supporting Dynamically Typed Languages on the Java Platform`*)`:cite-ref-13[`F5bf`_`[13`#cite-note-13]`_`f] added a new `B100`F9d9invokedynamic`f`b instruction at the JVM level, to allow method invocation relying on dynamic `F33f`_`[type checking`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Type_system]`_`f (instead of the extant statically type-checked `B100`F9d9invokevirtual`f`b instruction). The `F33f`_`[Da Vinci Machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Da_Vinci_Machine]`_`f is a prototype virtual machine implementation that hosts JVM extensions aimed at supporting dynamic languages. All JVMs supporting `F33f`_`[JSE`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_Platform,_Standard_Edition]`_`f 7 also include the `B100`F9d9invokedynamic`f`b opcode.

>>See also

• `F33f`_`[Byte Code Engineering Library`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Byte_Code_Engineering_Library]`_`f
• `F33f`_`[Common Intermediate Language`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Common_Intermediate_Language]`_`f (CIL), Microsoft's rival to Java bytecode
• `F33f`_`[Java backporting tools`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_backporting_tools]`_`f
• `F33f`_`[Java class file`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_class_file]`_`f
• `F33f`_`[Java virtual machine`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_virtual_machine]`_`f
• `F33f`_`[JStik`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=JStik]`_`f
• `F33f`_`[ObjectWeb ASM`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ObjectWeb_ASM]`_`f
• `F33f`_`[List of Java bytecode instructions`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=List_of_Java_bytecode_instructions]`_`f
• `F33f`_`[List of JVM languages`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=List_of_JVM_languages]`_`f

>>References

`:cite-note-oracle-jvm-spec-1`!1.`! `F0af`_`[↑`#cite-ref-oracle-jvm-spec-1-0]`_`f "Java Virtual Machine Specification". Oracle. Retrieved 14 November 2023.
`:cite-note-jvm-book-2`!2.`! `F0af`_`[↑`#cite-ref-jvm-book-2-0]`_`f `:citereflindholm2015`aLindholm, Tim (2015). `*The Java Virtual Machine Specification`*. Oracle. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0133905908.
`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f `:citerefarnold1996`aArnold, Ken (1996). "The Java Programming Language". `*Sun Microsystems`*. `!1`! (1): 30–40.
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f "IBM Developer". `*developer.ibm.com`*. Retrieved 20 February 2006.
`:cite-note-jvm-5`!5.`! `F0af`_`[↑`#cite-ref-jvm-5-0]`_`f `:citereflindholmyellinbrachabuckley2015`aLindholm, Tim; Yellin, Frank; Bracha, Gilad; Buckley, Alex (13 February 2015). `*The Java Virtual Machine Specification`* (Java SE 8 ed.).
`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f "Jasmin Home Page". `*jasmin.sourceforge.net`*. Retrieved 2 June 2024.
`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `:citerefhuang`aHuang, James Jianbo. "Jamaica: The Java virtual machine (JVM) macro assembler". `*JavaWorld`*. Archived from the original on 14 November 2023. Retrieved 2 June 2024.
`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f "Storyyeller/Krakatau". 1 June 2024. Retrieved 2 June 2024 – via GitHub.
`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f "Lilac - a Java assembler". `*lilac.sourceforge.net`*. Retrieved 2 June 2024.
`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f "FPC New Features 3.0.0 - Free Pascal wiki". `*wiki.freepascal.org`*. Retrieved 2 June 2024.
`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f "FPC JVM - Free Pascal wiki". `*wiki.freepascal.org`*. Retrieved 2 June 2024.
`:cite-note-12`!12.`! `F0af`_`[↑`#cite-ref-12]`_`f `:citerefnutter2007`aNutter, Charles (3 January 2007). "InvokeDynamic: Actually Useful?". Retrieved 25 January 2008.
`:cite-note-13`!13.`! `F0af`_`[↑`#cite-ref-13]`_`f "The Java Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 292". `*www.jcp.org`*. Retrieved 2 June 2024.

>>External links

The Wikibook

Java Programming

has a page on the topic of:

Java bytecode

• Oracle's Java Virtual Machine Specification
• Programming Languages for the Java Virtual Machine
• Bytecode Visualizer – bytecode viewer and debugger (free Eclipse plugin)
• AdaptJ StackTrace – bytecode level debugging with a full control of the stack, the local variables, and the execution flow
• Java Class Unpacker – plugin for Total Commander, it lets open class files as compressed archives and see fields and methods as files. The bytecode can be viewed as text using F3

`c`F0af`_`[↑ Back to top`#top]`_`f`a